{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^{*}$ should match a target distribution defined by taking the distribution for the next state $S_{t+1}$ and action $a^{*}_{t+1} = \\pi^{*}(S_{t+1})$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^{*}_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=-1)\n",
    "        dist = dist.clamp(min=1e-3)  # for avoiding nans\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device),\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"]).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (self.batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 2000\n",
    "batch_size = 32\n",
    "target_update = 150\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/categorical_dqn/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/categorical_dqn/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                               "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /Users/jinwoo.park/Repositories/rainbow-is-all-you-need/videos/categorical_dqn/rl-video-episode-0.mp4\n",
      "score:  200.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/categorical_dqn\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/categorical_dqn/rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dlengine_env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
